package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 用户控制器（Controller）
 * 负责处理 HTTP 请求，返回 JSON 响应
 *
 * @RestController - 组合注解，等同于 @Controller + @ResponseBody
 *                   表示这是一个 RESTful 控制器，所有方法返回 JSON 数据
 * @RequestMapping - 定义该控制器的基础路径
 * @RequiredArgsConstructor - Lombok 注解，自动生成构造函数（用于依赖注入）
 * @Slf4j - Lombok 注解，自动生成日志对象 log
 */
@RestController
@RequestMapping("/api/users")
@RequiredArgsConstructor
@Slf4j
public class UserController {

    // 依赖注入 UserService
    private final UserService userService;

    /**
     * 创建新用户
     * POST /api/users
     *
     * @PostMapping - 处理 HTTP POST 请求
     * @RequestBody - 将请求体中的 JSON 数据转换为 User 对象
     * @Valid - 启用数据验证（验证 @NotBlank、@Email 等注解）
     *
     * @param user 用户信息（从请求体获取）
     * @return 创建成功的用户对象
     *
     * 请求示例：
     * POST http://localhost:8080/api/users
     * Content-Type: application/json
     * {
     *   "name": "张三",
     *   "email": "zhangsan@example.com"
     * }
     */
    @PostMapping
    public ResponseEntity<User> createUser(@Valid @RequestBody User user) {
        log.info("收到创建用户请求: {}", user.getEmail());

        try {
            User createdUser = userService.createUser(user);
            return ResponseEntity.status(HttpStatus.CREATED).body(createdUser);
        } catch (RuntimeException e) {
            log.error("创建用户失败: {}", e.getMessage());
            throw e;
        }
    }

    /**
     * 获取所有用户
     * GET /api/users
     *
     * @GetMapping - 处理 HTTP GET 请求
     *
     * @return 所有用户列表
     *
     * 请求示例：
     * GET http://localhost:8080/api/users
     */
    @GetMapping
    public ResponseEntity<List<User>> getAllUsers() {
        log.info("收到查询所有用户请求");

        List<User> users = userService.getAllUsers();
        return ResponseEntity.ok(users);
    }

    /**
     * 根据 ID 获取用户
     * GET /api/users/{id}
     *
     * @PathVariable - 从 URL 路径中获取参数
     *
     * @param id 用户ID（从 URL 路径获取）
     * @return 用户对象
     *
     * 请求示例：
     * GET http://localhost:8080/api/users/1
     */
    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        log.info("收到查询用户请求，ID: {}", id);

        try {
            User user = userService.getUserById(id);
            return ResponseEntity.ok(user);
        } catch (RuntimeException e) {
            log.error("查询用户失败: {}", e.getMessage());
            throw e;
        }
    }

    /**
     * 根据姓名模糊查询用户
     * GET /api/users/search?name=张
     *
     * @RequestParam - 从 URL 查询参数中获取值
     *
     * @param name 用户姓名（支持部分匹配）
     * @return 匹配的用户列表
     *
     * 请求示例：
     * GET http://localhost:8080/api/users/search?name=张
     */
    @GetMapping("/search")
    public ResponseEntity<List<User>> searchUsers(@RequestParam String name) {
        log.info("收到搜索用户请求，姓名包含: {}", name);

        List<User> users = userService.searchUsersByName(name);
        return ResponseEntity.ok(users);
    }

    /**
     * 更新用户信息
     * PUT /api/users/{id}
     *
     * @PutMapping - 处理 HTTP PUT 请求（用于完整更新资源）
     *
     * @param id 用户ID（从 URL 路径获取）
     * @param user 新的用户信息（从请求体获取）
     * @return 更新后的用户对象
     *
     * 请求示例：
     * PUT http://localhost:8080/api/users/1
     * Content-Type: application/json
     * {
     *   "name": "张三三",
     *   "email": "zhangsansan@example.com"
     * }
     */
    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(
            @PathVariable Long id,
            @Valid @RequestBody User user) {
        log.info("收到更新用户请求，ID: {}", id);

        try {
            User updatedUser = userService.updateUser(id, user);
            return ResponseEntity.ok(updatedUser);
        } catch (RuntimeException e) {
            log.error("更新用户失败: {}", e.getMessage());
            throw e;
        }
    }

    /**
     * 删除用户
     * DELETE /api/users/{id}
     *
     * @DeleteMapping - 处理 HTTP DELETE 请求
     *
     * @param id 用户ID（从 URL 路径获取）
     * @return 删除成功消息
     *
     * 请求示例：
     * DELETE http://localhost:8080/api/users/1
     */
    @DeleteMapping("/{id}")
    public ResponseEntity<Map<String, String>> deleteUser(@PathVariable Long id) {
        log.info("收到删除用户请求，ID: {}", id);

        try {
            userService.deleteUser(id);

            Map<String, String> response = new HashMap<>();
            response.put("message", "用户删除成功");
            response.put("id", id.toString());

            return ResponseEntity.ok(response);
        } catch (RuntimeException e) {
            log.error("删除用户失败: {}", e.getMessage());
            throw e;
        }
    }

    /**
     * 全局异常处理
     * 捕获 Controller 中抛出的所有 RuntimeException
     *
     * @ExceptionHandler - 声明异常处理方法
     *
     * @param e 异常对象
     * @return 错误信息
     */
    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<Map<String, String>> handleRuntimeException(RuntimeException e) {
        Map<String, String> errorResponse = new HashMap<>();
        errorResponse.put("error", e.getMessage());

        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
}
